/**
 * 
 */
package fr.thelem.gestiondemandesthelem.web.adminactions;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import fr.thelem.gestiondemandesthelem.dao.model.CDDemandeEntity;
import fr.thelem.gestiondemandesthelem.dao.model.CDEtapeEntity;
import fr.thelem.gestiondemandesthelem.dao.model.CDParametreDemandeEntity;
import fr.thelem.gestiondemandesthelem.dao.model.CDParametreDemandeValeursEntity;
import fr.thelem.gestiondemandesthelem.dao.model.CDParametreEtapeEntity;
import fr.thelem.gestiondemandesthelem.dao.model.CDPointDeControleEntity;
import fr.thelem.gestiondemandesthelem.dao.model.CPParametreEtapeEntity;
import fr.thelem.gestiondemandesthelem.dao.model.CategorieEntity;
import fr.thelem.gestiondemandesthelem.dao.model.CorrespondanceParametresEntity;
import fr.thelem.gestiondemandesthelem.dao.model.SousCategorieEntity;
import fr.thelem.gestiondemandesthelem.dao.model.TypeDemandeEntity;
import fr.thelem.gestiondemandesthelem.service.IAppliService;
import fr.thelem.gestiondemandesthelem.web.actions.BaseAction;

/**
 *
 */
public class ParametrageDemandesAction extends BaseAction {

    /** Attribut serialVersionUID */
    private static final long serialVersionUID = 1L;

    private IAppliService appliService;

    private String erreur;
    private String erreur2;
    private String erreur3;
    private String erreur4;
    private String typeDemande;
    private Map<String, String> mapTypesDemande = new HashMap<String, String>();
    private int idTypeDemande;

    private String categorie;
    private Map<String, String> mapCategories = new HashMap<String, String>();
    private int idCategorie;

    private String sousCategorie;
    private Map<String, String> mapSousCategories = new HashMap<String, String>();
    private int idSousCategorie;

    private String CDDemande;
    private Map<String, String> mapCDDemandes = new HashMap<String, String>();
    private int idCDDemande;

    private String CDEtape;
    private String descriptionCDEtape;
    private Map<String, String> mapCDEtapes = new HashMap<String, String>();
    private int idCDEtape;

    private String CDPointControle;
    private String typeSaisieCDPointControle;
    private int numeroCDPointControle;
    private String numeroEnvoyeCDPointControle;
    private List<String> listTypesSaisieCDPointControle;
    private Map<String, String> mapCDPointsControle = new HashMap<String, String>();
    private LinkedList<String> listeIdCDPointsControle = new LinkedList<String>();
    private LinkedList<String> listeNomsCDPointsControle = new LinkedList<String>();
    private int idCDPointControle;

    private String CDParametreDemande;
    private String descriptionCDParametreDemande;
    private String obligatoireCDParametreDemande;
    private String typeSaisieCDParametreDemande;
    private List<String> listTypesSaisieCDParametreDemande;
    private List<String> listObligatoireCDParametreDemande;
    private Map<String, String> mapCDParametresDemande = new HashMap<String, String>();
    private int idCDParametreDemande;
    private String valeursCDParametreDemande;

    private String CDParametreEtape;
    private String descriptionCDParametreEtape;
    private String typeSaisieCDParametreEtape;
    private String valeurFixeCDParametreEtape;
    private List<String> listTypesSaisieCDParametreEtape;
    private Map<String, String> mapCDParametresEtape = new HashMap<String, String>();
    private int idCDParametreEtape;

    private String CDParametreDemandeValeurs;
    private Map<String, String> mapCDParametresDemandeValeurs = new HashMap<String, String>();
    private int idCDParametreDemandeValeurs;

    private String CPParametreEtape;
    private Map<String, String> mapCPParametresEtape = new HashMap<String, String>();

    private int idCPParametreEtape;
    private int idCorrespondanceParametres;
    private int idCorrespondanceParametresDemande;
    private int idCorrespondanceParametresEtape;
    private String corpardem;
    private String corparet;
    private Map<String, String> mapCorrespondancesParametresDemande = new HashMap<String, String>();
    private Map<String, String> mapCorrespondancesParametresEtape = new HashMap<String, String>();
    private Map<String, String> mapCorrespondancesParametres = new HashMap<String, String>();

    /**
     * Constructeur
     */
    public ParametrageDemandesAction() {
        super();
        this.listTypesSaisieCDPointControle = new ArrayList<String>();
        this.listTypesSaisieCDPointControle.add("Zone de saisie");
        this.listTypesSaisieCDPointControle.add("Case à cocher");
        this.listTypesSaisieCDParametreDemande = new ArrayList<String>();
        this.listTypesSaisieCDParametreDemande.add("Numérique");
        this.listTypesSaisieCDParametreDemande.add("Texte libre");
        this.listTypesSaisieCDParametreDemande.add("Liste");
        this.listTypesSaisieCDParametreDemande.add("Liste à sélection simple");
        this.listTypesSaisieCDParametreDemande.add("Liste à sélection multiple");
        this.listTypesSaisieCDParametreDemande.add("Date");
        this.listTypesSaisieCDParametreDemande.add("Fichier");
        this.listObligatoireCDParametreDemande = new ArrayList<String>();
        this.listObligatoireCDParametreDemande.add("Obligatoire");
        this.listObligatoireCDParametreDemande.add("Facultatif");
        this.listTypesSaisieCDParametreEtape = new ArrayList<String>();
        this.listTypesSaisieCDParametreEtape.add("Utilisateur");
        this.listTypesSaisieCDParametreEtape.add("Administrateur");
    }

    /**
     * Accesseur de appliService
     * 
     * @return le appliService
     */
    public IAppliService getAppliService() {
        return appliService;
    }

    /**
     * Affectation de appliService
     * 
     * @param appliService appliService à affecter
     */
    public void setAppliService(IAppliService appliService) {
        this.appliService = appliService;
    }

    /**
     * Accesseur de erreur
     * 
     * @return le erreur
     */
    public String getErreur() {
        return erreur;
    }

    /**
     * Affectation de erreur
     * 
     * @param erreur erreur à affecter
     */
    public void setErreur(String erreur) {
        this.erreur = erreur;
    }

    /**
     * Accesseur de erreur2
     * 
     * @return le erreur2
     */
    public String getErreur2() {
        return erreur2;
    }

    /**
     * Affectation de erreur2
     * 
     * @param erreur2 erreur2 à affecter
     */
    public void setErreur2(String erreur2) {
        this.erreur2 = erreur2;
    }

    /**
     * Accesseur de erreur3
     * 
     * @return le erreur3
     */
    public String getErreur3() {
        return erreur3;
    }

    /**
     * Affectation de erreur3
     * 
     * @param erreur3 erreur3 à affecter
     */
    public void setErreur3(String erreur3) {
        this.erreur3 = erreur3;
    }

    /**
     * Accesseur de erreur4
     * 
     * @return le erreur4
     */
    public String getErreur4() {
        return erreur4;
    }

    /**
     * Affectation de erreur4
     * 
     * @param erreur4 erreur4 à affecter
     */
    public void setErreur4(String erreur4) {
        this.erreur4 = erreur4;
    }

    /**
     * Accesseur de typeDemande
     * 
     * @return le typeDemande
     */
    public String getTypeDemande() {
        return typeDemande;
    }

    /**
     * Affectation de typeDemande
     * 
     * @param typeDemande typeDemande à affecter
     */
    public void setTypeDemande(String typeDemande) {
        this.typeDemande = typeDemande;
    }

    /**
     * Accesseur de mapTypesDemande
     * 
     * @return le mapTypesDemande
     */
    public Map<String, String> getMapTypesDemande() {
        return mapTypesDemande;
    }

    /**
     * Affectation de mapTypesDemande
     * 
     * @param mapTypesDemande mapTypesDemande à affecter
     */
    public void setMapTypesDemande(Map<String, String> mapTypesDemande) {
        this.mapTypesDemande = mapTypesDemande;
    }

    /**
     * Accesseur de idTypeDemande
     * 
     * @return le idTypeDemande
     */
    public int getIdTypeDemande() {
        return idTypeDemande;
    }

    /**
     * Affectation de idTypeDemande
     * 
     * @param idTypeDemande idTypeDemande à affecter
     */
    public void setIdTypeDemande(int idTypeDemande) {
        this.idTypeDemande = idTypeDemande;
    }

    /**
     * Accesseur de categorie
     * 
     * @return le categorie
     */
    public String getCategorie() {
        return categorie;
    }

    /**
     * Affectation de categorie
     * 
     * @param categorie categorie à affecter
     */
    public void setCategorie(String categorie) {
        this.categorie = categorie;
    }

    /**
     * Accesseur de mapCategories
     * 
     * @return le mapCategories
     */
    public Map<String, String> getMapCategories() {
        return mapCategories;
    }

    /**
     * Affectation de mapCategories
     * 
     * @param mapCategories mapCategories à affecter
     */
    public void setMapCategories(Map<String, String> mapCategories) {
        this.mapCategories = mapCategories;
    }

    /**
     * Accesseur de idCategorie
     * 
     * @return le idCategorie
     */
    public int getIdCategorie() {
        return idCategorie;
    }

    /**
     * Affectation de idCategorie
     * 
     * @param idCategorie idCategorie à affecter
     */
    public void setIdCategorie(int idCategorie) {
        this.idCategorie = idCategorie;
    }

    /**
     * Accesseur de sousCategorie
     * 
     * @return le sousCategorie
     */
    public String getSousCategorie() {
        return sousCategorie;
    }

    /**
     * Affectation de sousCategorie
     * 
     * @param sousCategorie sousCategorie à affecter
     */
    public void setSousCategorie(String sousCategorie) {
        this.sousCategorie = sousCategorie;
    }

    /**
     * Accesseur de mapSousCategories
     * 
     * @return le mapSousCategories
     */
    public Map<String, String> getMapSousCategories() {
        return mapSousCategories;
    }

    /**
     * Affectation de mapSousCategories
     * 
     * @param mapSousCategories mapSousCategories à affecter
     */
    public void setMapSousCategories(Map<String, String> mapSousCategories) {
        this.mapSousCategories = mapSousCategories;
    }

    /**
     * Accesseur de idSousCategorie
     * 
     * @return le idSousCategorie
     */
    public int getIdSousCategorie() {
        return idSousCategorie;
    }

    /**
     * Affectation de idSousCategorie
     * 
     * @param idSousCategorie idSousCategorie à affecter
     */
    public void setIdSousCategorie(int idSousCategorie) {
        this.idSousCategorie = idSousCategorie;
    }

    /**
     * Accesseur de cDDemande
     * 
     * @return le cDDemande
     */
    public String getCDDemande() {
        return CDDemande;
    }

    /**
     * Affectation de cDDemande
     * 
     * @param cDDemande cDDemande à affecter
     */
    public void setCDDemande(String cDDemande) {
        CDDemande = cDDemande;
    }

    /**
     * Accesseur de mapCDDemandes
     * 
     * @return le mapCDDemandes
     */
    public Map<String, String> getMapCDDemandes() {
        return mapCDDemandes;
    }

    /**
     * Affectation de mapCDDemandes
     * 
     * @param mapCDDemandes mapCDDemandes à affecter
     */
    public void setMapCDDemandes(Map<String, String> mapCDDemandes) {
        this.mapCDDemandes = mapCDDemandes;
    }

    /**
     * Accesseur de listObligatoireCDParametreDemande
     * 
     * @return le listObligatoireCDParametreDemande
     */
    public List<String> getListObligatoireCDParametreDemande() {
        return listObligatoireCDParametreDemande;
    }

    /**
     * Affectation de listObligatoireCDParametreDemande
     * 
     * @param listObligatoireCDParametreDemande listObligatoireCDParametreDemande à affecter
     */
    public void setListObligatoireCDParametreDemande(List<String> listObligatoireCDParametreDemande) {
        this.listObligatoireCDParametreDemande = listObligatoireCDParametreDemande;
    }

    public String getDefaultObligatoireCDParametreDemande() {
        return "Obligatoire";
    }

    /**
     * Accesseur de idCDDemande
     * 
     * @return le idCDDemande
     */
    public int getIdCDDemande() {
        return idCDDemande;
    }

    /**
     * Affectation de idCDDemande
     * 
     * @param idCDDemande idCDDemande à affecter
     */
    public void setIdCDDemande(int idCDDemande) {
        this.idCDDemande = idCDDemande;
    }

    /**
     * Accesseur de cDEtape
     * 
     * @return le cDEtape
     */
    public String getCDEtape() {
        return CDEtape;
    }

    /**
     * Affectation de cDEtape
     * 
     * @param cDetape cDEtape à affecter
     */
    public void setCDEtape(String cDEtape) {
        CDEtape = cDEtape;
    }

    /**
     * Accesseur de descriptionCDEtape
     * 
     * @return le descriptionCDEtape
     */
    public String getDescriptionCDEtape() {
        return descriptionCDEtape;
    }

    /**
     * Affectation de descriptionCDEtape
     * 
     * @param descriptionCDEtape descriptionCDEtape à affecter
     */
    public void setDescriptionCDEtape(String descriptionCDEtape) {
        this.descriptionCDEtape = descriptionCDEtape;
    }

    /**
     * Accesseur de typeSaisieCDParametreEtape
     * 
     * @return le typeSaisieCDParametreEtape
     */
    public String getTypeSaisieCDParametreEtape() {
        return typeSaisieCDParametreEtape;
    }

    /**
     * Affectation de typeSaisieCDParametreEtape
     * 
     * @param typeSaisieCDParametreEtape typeSaisieCDParametreEtape à affecter
     */
    public void setTypeSaisieCDParametreEtape(String typeSaisieCDParametreEtape) {
        this.typeSaisieCDParametreEtape = typeSaisieCDParametreEtape;
    }

    /**
     * Accesseur de valeurFixeCDParametreEtape
     * 
     * @return le valeurFixeCDParametreEtape
     */
    public String getValeurFixeCDParametreEtape() {
        return valeurFixeCDParametreEtape;
    }

    /**
     * Affectation de valeurFixeCDParametreEtape
     * 
     * @param valeurFixeCDParametreEtape valeurFixeCDParametreEtape à affecter
     */
    public void setValeurFixeCDParametreEtape(String valeurFixeCDParametreEtape) {
        this.valeurFixeCDParametreEtape = valeurFixeCDParametreEtape;
    }

    /**
     * Accesseur de listTypesSaisieCDParametreEtape
     * 
     * @return le listTypesSaisieCDParametreEtape
     */
    public List<String> getListTypesSaisieCDParametreEtape() {
        return listTypesSaisieCDParametreEtape;
    }

    /**
     * Affectation de listTypesSaisieCDParametreEtape
     * 
     * @param listTypesSaisieCDParametreEtape listTypesSaisieCDParametreEtape à affecter
     */
    public void setListTypesSaisieCDParametreEtape(List<String> listTypesSaisieCDParametreEtape) {
        this.listTypesSaisieCDParametreEtape = listTypesSaisieCDParametreEtape;
    }

    /**
     * Accesseur de mapCDEtapes
     * 
     * @return le mapCDEtapes
     */
    public Map<String, String> getMapCDEtapes() {
        return mapCDEtapes;
    }

    /**
     * Affectation de mapCDEtapes
     * 
     * @param mapCDEtapes mapCDEtapes à affecter
     */
    public void setMapCDEtapes(Map<String, String> mapCDEtapes) {
        this.mapCDEtapes = mapCDEtapes;
    }

    /**
     * Accesseur de idCDEtape
     * 
     * @return le idCDEtape
     */
    public int getIdCDEtape() {
        return idCDEtape;
    }

    /**
     * Affectation de idCDEtape
     * 
     * @param idCDEtape idCDEtape à affecter
     */
    public void setIdCDEtape(int idCDEtape) {
        this.idCDEtape = idCDEtape;
    }

    /**
     * Accesseur de cDPointControle
     * 
     * @return le cDPointControle
     */
    public String getCDPointControle() {
        return CDPointControle;
    }

    /**
     * Affectation de cDPointControle
     * 
     * @param cDPointControle cDPointControle à affecter
     */
    public void setCDPointControle(String cDPointControle) {
        CDPointControle = cDPointControle;
    }

    /**
     * Accesseur de typeSaisieCDPointControle
     * 
     * @return le typeSaisieCDPointControle
     */
    public String getTypeSaisieCDPointControle() {
        return typeSaisieCDPointControle;
    }

    /**
     * Affectation de typeSaisieCDPointControle
     * 
     * @param typeSaisieCDPointControle typeSaisieCDPointControle à affecter
     */
    public void setTypeSaisieCDPointControle(String typeSaisieCDPointControle) {
        this.typeSaisieCDPointControle = typeSaisieCDPointControle;
    }

    /**
     * Accesseur de numeroCDPointControle
     * 
     * @return le numeroCDPointControle
     */
    public int getNumeroCDPointControle() {
        return numeroCDPointControle;
    }

    /**
     * Affectation de numeroCDPointControle
     * 
     * @param numeroCDPointControle numeroCDPointControle à affecter
     */
    public void setNumeroCDPointControle(int numeroCDPointControle) {
        this.numeroCDPointControle = numeroCDPointControle;
    }

    /**
     * Accesseur de numeroEnvoyeCDPointControle
     * 
     * @return le numeroEnvoyeCDPointControle
     */
    public String getNumeroEnvoyeCDPointControle() {
        return numeroEnvoyeCDPointControle;
    }

    /**
     * Affectation de numeroEnvoyeCDPointControle
     * 
     * @param numeroEnvoyeCDPointControle numeroEnvoyeCDPointControle à affecter
     */
    public void setNumeroEnvoyeCDPointControle(String numeroEnvoyeCDPointControle) {
        this.numeroEnvoyeCDPointControle = numeroEnvoyeCDPointControle;
    }

    /**
     * Accesseur de listTypesSaisieCDPointControle
     * 
     * @return le listTypesSaisieCDPointControle
     */
    public List<String> getListTypesSaisieCDPointControle() {
        return listTypesSaisieCDPointControle;
    }

    /**
     * Affectation de listTypesSaisieCDPointControle
     * 
     * @param listTypesSaisieCDPointControle listTypesSaisieCDPointControle à affecter
     */
    public void setListTypesSaisieCDPointControle(List<String> listTypesSaisieCDPointControle) {
        this.listTypesSaisieCDPointControle = listTypesSaisieCDPointControle;
    }

    /**
     * Accesseur de mapCDPointsControle
     * 
     * @return le mapCDPointsControle
     */
    public Map<String, String> getMapCDPointsControle() {
        return mapCDPointsControle;
    }

    /**
     * Affectation de mapCDPointsControle
     * 
     * @param mapCDPointsControle mapCDPointsControle à affecter
     */
    public void setMapCDPointsControle(Map<String, String> mapCDPointsControle) {
        this.mapCDPointsControle = mapCDPointsControle;
    }

    /**
     * Accesseur de listeIdCDPointsControle
     * 
     * @return le listeIdCDPointsControle
     */
    public LinkedList<String> getListeIdCDPointsControle() {
        return listeIdCDPointsControle;
    }

    /**
     * Affectation de listeIdCDPointsControle
     * 
     * @param listeIdCDPointsControle listeIdCDPointsControle à affecter
     */
    public void setListeIdCDPointsControle(LinkedList<String> listeIdCDPointsControle) {
        this.listeIdCDPointsControle = listeIdCDPointsControle;
    }

    /**
     * Accesseur de listeNomsCDPointsControle
     * 
     * @return le listeNomsCDPointsControle
     */
    public LinkedList<String> getListeNomsCDPointsControle() {
        return listeNomsCDPointsControle;
    }

    /**
     * Affectation de listeNomsCDPointsControle
     * 
     * @param listeNomsCDPointsControle listeNomsCDPointsControle à affecter
     */
    public void setListeNomsCDPointsControle(LinkedList<String> listeNomsCDPointsControle) {
        this.listeNomsCDPointsControle = listeNomsCDPointsControle;
    }

    /**
     * Accesseur de idCDPointControle
     * 
     * @return le idCDPointControle
     */
    public int getIdCDPointControle() {
        return idCDPointControle;
    }

    /**
     * Affectation de idCDPointControle
     * 
     * @param idCDPointControle idCDPointControle à affecter
     */
    public void setIdCDPointControle(int idCDPointControle) {
        this.idCDPointControle = idCDPointControle;
    }

    /**
     * Accesseur de cDParametreDemande
     * 
     * @return le cDParametreDemande
     */
    public String getCDParametreDemande() {
        return CDParametreDemande;
    }

    /**
     * Affectation de cDParametreDemande
     * 
     * @param cDParametreDemande cDParametreDemande à affecter
     */
    public void setCDParametreDemande(String cDParametreDemande) {
        CDParametreDemande = cDParametreDemande;
    }

    /**
     * Accesseur de descriptionCDParametreDemande
     * 
     * @return le descriptionCDParametreDemande
     */
    public String getDescriptionCDParametreDemande() {
        return descriptionCDParametreDemande;
    }

    /**
     * Affectation de descriptionCDParametreDemande
     * 
     * @param descriptionCDParametreDemande descriptionCDParametreDemande à affecter
     */
    public void setDescriptionCDParametreDemande(String descriptionCDParametreDemande) {
        this.descriptionCDParametreDemande = descriptionCDParametreDemande;
    }

    /**
     * Accesseur de obligatoireCDParametreDemande
     * 
     * @return le obligatoireCDParametreDemande
     */
    public String getObligatoireCDParametreDemande() {
        return obligatoireCDParametreDemande;
    }

    /**
     * Affectation de obligatoireCDParametreDemande
     * 
     * @param obligatoireCDParametreDemande obligatoireCDParametreDemande à affecter
     */
    public void setObligatoireCDParametreDemande(String obligatoireCDParametreDemande) {
        this.obligatoireCDParametreDemande = obligatoireCDParametreDemande;
    }

    /**
     * Accesseur de typeSaisieCDParametreDemande
     * 
     * @return le typeSaisieCDParametreDemande
     */
    public String getTypeSaisieCDParametreDemande() {
        return typeSaisieCDParametreDemande;
    }

    /**
     * Affectation de typeSaisieCDParametreDemande
     * 
     * @param typeSaisieCDParametreDemande typeSaisieCDParametreDemande à affecter
     */
    public void setTypeSaisieCDParametreDemande(String typeSaisieCDParametreDemande) {
        this.typeSaisieCDParametreDemande = typeSaisieCDParametreDemande;
    }

    /**
     * Accesseur de listTypesSaisieCDParametreDemande
     * 
     * @return le listTypesSaisieCDParametreDemande
     */
    public List<String> getListTypesSaisieCDParametreDemande() {
        return listTypesSaisieCDParametreDemande;
    }

    /**
     * Affectation de listTypesSaisieCDParametreDemande
     * 
     * @param listTypesSaisieCDParametreDemande listTypesSaisieCDParametreDemande à affecter
     */
    public void setListTypesSaisieCDParametreDemande(List<String> listTypesSaisieCDParametreDemande) {
        this.listTypesSaisieCDParametreDemande = listTypesSaisieCDParametreDemande;
    }

    /**
     * Accesseur de mapCDParametresDemande
     * 
     * @return le mapCDParametresDemande
     */
    public Map<String, String> getMapCDParametresDemande() {
        return mapCDParametresDemande;
    }

    /**
     * Affectation de mapCDParametresDemande
     * 
     * @param mapCDParametresDemande mapCDParametresDemande à affecter
     */
    public void setMapCDParametresDemande(Map<String, String> mapCDParametresDemande) {
        this.mapCDParametresDemande = mapCDParametresDemande;
    }

    /**
     * Accesseur de idCDParametreDemande
     * 
     * @return le idCDParametreDemande
     */
    public int getIdCDParametreDemande() {
        return idCDParametreDemande;
    }

    /**
     * Affectation de idCDParametreDemande
     * 
     * @param idCDParametreDemande idCDParametreDemande à affecter
     */
    public void setIdCDParametreDemande(int idCDParametreDemande) {
        this.idCDParametreDemande = idCDParametreDemande;
    }

    /**
     * Accesseur de cDParametreEtape
     * 
     * @return le cDParametreEtape
     */
    public String getCDParametreEtape() {
        return CDParametreEtape;
    }

    /**
     * Affectation de cDParametreEtape
     * 
     * @param cDParametreEtape cDParametreEtape à affecter
     */
    public void setCDParametreEtape(String cDParametreEtape) {
        CDParametreEtape = cDParametreEtape;
    }

    /**
     * Accesseur de mapCDParametresEtape
     * 
     * @return le mapCDParametresEtape
     */
    public Map<String, String> getMapCDParametresEtape() {
        return mapCDParametresEtape;
    }

    /**
     * Affectation de mapCDParametresEtape
     * 
     * @param mapCDParametresEtape mapCDParametresEtape à affecter
     */
    public void setMapCDParametresEtape(Map<String, String> mapCDParametresEtape) {
        this.mapCDParametresEtape = mapCDParametresEtape;
    }

    /**
     * Accesseur de idCDParametreEtape
     * 
     * @return le idCDParametreEtape
     */
    public int getIdCDParametreEtape() {
        return idCDParametreEtape;
    }

    /**
     * Affectation de idCDParametreEtape
     * 
     * @param idCDParametreEtape idCDParametreEtape à affecter
     */
    public void setIdCDParametreEtape(int idCDParametreEtape) {
        this.idCDParametreEtape = idCDParametreEtape;
    }

    /**
     * Accesseur de descriptionCDParametreEtape
     * 
     * @return le descriptionCDParametreEtape
     */
    public String getDescriptionCDParametreEtape() {
        return descriptionCDParametreEtape;
    }

    /**
     * Affectation de descriptionCDParametreEtape
     * 
     * @param descriptionCDParametreEtape descriptionCDParametreEtape à affecter
     */
    public void setDescriptionCDParametreEtape(String descriptionCDParametreEtape) {
        this.descriptionCDParametreEtape = descriptionCDParametreEtape;
    }

    /**
     * Accesseur de cDParametreDemandeValeurs
     * 
     * @return le cDParametreDemandeValeurs
     */
    public String getCDParametreDemandeValeurs() {
        return CDParametreDemandeValeurs;
    }

    /**
     * Affectation de cDParametreDemandeValeurs
     * 
     * @param cDParametreDemandeValeurs cDParametreDemandeValeurs à affecter
     */
    public void setCDParametreDemandeValeurs(String cDParametreDemandeValeurs) {
        CDParametreDemandeValeurs = cDParametreDemandeValeurs;
    }

    /**
     * Accesseur de mapCDParametresDemandeValeurs
     * 
     * @return le mapCDParametresDemandeValeurs
     */
    public Map<String, String> getMapCDParametresDemandeValeurs() {
        return mapCDParametresDemandeValeurs;
    }

    /**
     * Affectation de mapCDParametresDemandeValeurs
     * 
     * @param mapCDParametresDemandeValeurs mapCDParametresDemandeValeurs à affecter
     */
    public void setMapCDParametresDemandeValeurs(Map<String, String> mapCDParametresDemandeValeurs) {
        this.mapCDParametresDemandeValeurs = mapCDParametresDemandeValeurs;
    }

    /**
     * Accesseur de idCDParametreDemandeValeurs
     * 
     * @return le idCDParametreDemandeValeurs
     */
    public int getIdCDParametreDemandeValeurs() {
        return idCDParametreDemandeValeurs;
    }

    /**
     * Affectation de idCDParametreDemandeValeurs
     * 
     * @param idCDParametreDemandeValeurs idCDParametreDemandeValeurs à affecter
     */
    public void setIdCDParametreDemandeValeurs(int idCDParametreDemandeValeurs) {
        this.idCDParametreDemandeValeurs = idCDParametreDemandeValeurs;
    }

    /**
     * Accesseur de cPParametreEtape
     * 
     * @return le cPParametreEtape
     */
    public String getCPParametreEtape() {
        return CPParametreEtape;
    }

    /**
     * Affectation de cPParametreEtape
     * 
     * @param cPParametreEtape cPParametreEtape à affecter
     */
    public void setCPParametreEtape(String cPParametreEtape) {
        CPParametreEtape = cPParametreEtape;
    }

    /**
     * Accesseur de mapCPParametresEtape
     * 
     * @return le mapCPParametresEtape
     */
    public Map<String, String> getMapCPParametresEtape() {
        return mapCPParametresEtape;
    }

    /**
     * Affectation de mapCPParametresEtape
     * 
     * @param mapCPParametresEtape mapCPParametresEtape à affecter
     */
    public void setMapCPParametresEtape(Map<String, String> mapCPParametresEtape) {
        this.mapCPParametresEtape = mapCPParametresEtape;
    }

    /**
     * Accesseur de idCPParametreEtape
     * 
     * @return le idCPParametreEtape
     */
    public int getIdCPParametreEtape() {
        return idCPParametreEtape;
    }

    /**
     * Affectation de idCPParametreEtape
     * 
     * @param idCPParametreEtape idCPParametreEtape à affecter
     */
    public void setIdCPParametreEtape(int idCPParametreEtape) {
        this.idCPParametreEtape = idCPParametreEtape;
    }

    /**
     * Accesseur de idCorrespondanceParametres
     * 
     * @return le idCorrespondanceParametres
     */
    public int getIdCorrespondanceParametres() {
        return idCorrespondanceParametres;
    }

    /**
     * Affectation de idCorrespondanceParametres
     * 
     * @param idCorrespondanceParametres idCorrespondanceParametres à affecter
     */
    public void setIdCorrespondanceParametres(int idCorrespondanceParametres) {
        this.idCorrespondanceParametres = idCorrespondanceParametres;
    }

    /**
     * Accesseur de idCorrespondanceParametresDemande
     * 
     * @return le idCorrespondanceParametresDemande
     */
    public int getIdCorrespondanceParametresDemande() {
        return idCorrespondanceParametresDemande;
    }

    /**
     * Affectation de idCorrespondanceParametresDemande
     * 
     * @param idCorrespondanceParametresDemande idCorrespondanceParametresDemande à affecter
     */
    public void setIdCorrespondanceParametresDemande(int idCorrespondanceParametresDemande) {
        this.idCorrespondanceParametresDemande = idCorrespondanceParametresDemande;
    }

    /**
     * Accesseur de idCorrespondanceParametresEtape
     * 
     * @return le idCorrespondanceParametresEtape
     */
    public int getIdCorrespondanceParametresEtape() {
        return idCorrespondanceParametresEtape;
    }

    /**
     * Affectation de idCorrespondanceParametresEtape
     * 
     * @param idCorrespondanceParametresEtape idCorrespondanceParametresEtape à affecter
     */
    public void setIdCorrespondanceParametresEtape(int idCorrespondanceParametresEtape) {
        this.idCorrespondanceParametresEtape = idCorrespondanceParametresEtape;
    }

    /**
     * Accesseur de corpardem
     * 
     * @return le corpardem
     */
    public String getCorpardem() {
        return corpardem;
    }

    /**
     * Affectation de corpardem
     * 
     * @param corpardem corpardem à affecter
     */
    public void setCorpardem(String corpardem) {
        this.corpardem = corpardem;
    }

    /**
     * Accesseur de corparet
     * 
     * @return le corparet
     */
    public String getCorparet() {
        return corparet;
    }

    /**
     * Affectation de corparet
     * 
     * @param corparet corparet à affecter
     */
    public void setCorparet(String corparet) {
        this.corparet = corparet;
    }

    /**
     * Accesseur de mapCorrespondancesParametresDemande
     * 
     * @return le mapCorrespondancesParametresDemande
     */
    public Map<String, String> getMapCorrespondancesParametresDemande() {
        return mapCorrespondancesParametresDemande;
    }

    /**
     * Affectation de mapCorrespondancesParametresDemande
     * 
     * @param mapCorrespondancesParametresDemande mapCorrespondancesParametresDemande à affecter
     */
    public void setMapCorrespondancesParametresDemande(Map<String, String> mapCorrespondancesParametresDemande) {
        this.mapCorrespondancesParametresDemande = mapCorrespondancesParametresDemande;
    }

    /**
     * Accesseur de mapCorrespondancesParametresEtape
     * 
     * @return le mapCorrespondancesParametresEtape
     */
    public Map<String, String> getMapCorrespondancesParametresEtape() {
        return mapCorrespondancesParametresEtape;
    }

    /**
     * Affectation de mapCorrespondancesParametresEtape
     * 
     * @param mapCorrespondancesParametresEtape mapCorrespondancesParametresEtape à affecter
     */
    public void setMapCorrespondancesParametresEtape(Map<String, String> mapCorrespondancesParametresEtape) {
        this.mapCorrespondancesParametresEtape = mapCorrespondancesParametresEtape;
    }

    /**
     * Accesseur de mapCorrespondancesParametres
     * 
     * @return le mapCorrespondancesParametres
     */
    public Map<String, String> getMapCorrespondancesParametres() {
        return mapCorrespondancesParametres;
    }

    /**
     * Affectation de mapCorrespondancesParametres
     * 
     * @param mapCorrespondancesParametres mapCorrespondancesParametres à affecter
     */
    public void setMapCorrespondancesParametres(Map<String, String> mapCorrespondancesParametres) {
        this.mapCorrespondancesParametres = mapCorrespondancesParametres;
    }

    /**
     * Fonction execute (s'execute à l'appel de l'action) {@inheritDoc}
     * 
     * @return String
     */
    public String execute() throws Exception {
        this.ajouterRoleSession();
        this.ajouterValeurSession("listeTypesDemande", appliService.recupererTypesDemande());
        return SUCCESS;
    }

    /**
     * Ajouter un type de demande
     * 
     * @return String
     */
    public String ajouterTypeDemande() throws Exception {
        try {
            if (typeDemande.equals("")) {
                erreur = getText("Admin.error.action.typedemande");
                return SUCCESS;
            }
            idTypeDemande = appliService.ajouterTypeDemande(typeDemande);
            return SUCCESS;
        } catch (RuntimeException re) {
            return ERROR;
        }
    }

    /**
     * Recuperer les types de demande
     * 
     * @return
     * @throws Exception
     */

    public String recupererTypesDemande() throws Exception {
        for (TypeDemandeEntity td : appliService.recupererTypesDemande()) {
            mapTypesDemande.put(String.valueOf(td.getIdentifiantTypeDemande()), td.getNomTypeDemande());
        }
        return SUCCESS;
    }

    /**
     * Supprimer un type de demande
     * 
     * @return
     * @throws Exception
     */
    public String supprimerTypeDemande() throws Exception {
        try {
            appliService.supprimerTypeDemande(idTypeDemande);
            return SUCCESS;
        } catch (Exception e) {
            return ERROR;
        }
    }

    /**
     * Ajouter une catégorie
     * 
     * @return String
     */
    public String ajouterCategorie() throws Exception {

        try {
            if (categorie.equals("")) {
                erreur = getText("Admin.error.action.categorie");
                return SUCCESS;
            }
            idCategorie = appliService.ajouterCategorie(idTypeDemande, categorie);
            return SUCCESS;

        } catch (RuntimeException re) {
            return ERROR;
        }
    }

    /**
     * Récupérer les catégories
     * 
     * @return
     */
    public String recupererCategories() throws Exception {
        for (CategorieEntity c : appliService.recupererCategories(idTypeDemande)) {
            mapCategories.put(String.valueOf(c.getIdentifiantCategorie()), c.getNomCategorie());
        }
        return SUCCESS;
    }

    /**
     * Supprimer une categorie
     * 
     * @return
     * @throws Exception
     */
    public String supprimerCategorie() throws Exception {
        try {
            appliService.supprimerCategorie(idCategorie);
            return SUCCESS;
        } catch (Exception e) {
            return ERROR;
        }
    }

    /**
     * Ajouter une sous-catégorie
     * 
     * @return String
     */
    public String ajouterSousCategorie() throws Exception {
        try {
            if (sousCategorie.equals("")) {
                erreur = getText("Admin.error.action.souscategorie");
                return SUCCESS;
            }
            idSousCategorie = appliService.ajouterSousCategorie(idCategorie, sousCategorie);
            return SUCCESS;

        } catch (RuntimeException re) {
            return ERROR;
        }
    }

    /**
     * Récupérer les catégories
     * 
     * @return
     */
    public String recupererSousCategories() throws Exception {
        for (SousCategorieEntity sc : appliService.recupererSousCategories(idCategorie)) {
            mapSousCategories.put(String.valueOf(sc.getIdentifiantSousCategorie()), sc.getNomSousCategorie());
        }
        return SUCCESS;
    }

    /**
     * Supprimer une sous-categorie
     * 
     * @return
     * @throws Exception
     */
    public String supprimerSousCategorie() throws Exception {
        try {
            appliService.supprimerSousCategorie(idSousCategorie);
            return SUCCESS;
        } catch (Exception e) {
            return ERROR;
        }
    }

    /**
     * Ajouter une CDDemande
     * 
     * @return String
     */
    public String ajouterCDDemande() throws Exception {
        try {
            if (CDDemande.equals("")) {
                erreur = getText("Admin.error.action.CDdemande");
                return SUCCESS;
            }
            idCDDemande = appliService.ajouterCDDemande(idTypeDemande, idSousCategorie, CDDemande);
            return SUCCESS;
        } catch (RuntimeException re) {
            return ERROR;
        }
    }

    /**
     * Récupérer les CDDemandes
     * 
     * @return
     */
    public String recupererCDDemandes() throws Exception {
        for (CDDemandeEntity d : appliService.recupererCDDemandes(idSousCategorie)) {
            mapCDDemandes.put(String.valueOf(d.getIdentifiantCDDemande()), d.getNomCDDemande());
        }
        return SUCCESS;
    }

    /**
     * Supprimer une CDDemande
     * 
     * @return
     * @throws Exception
     */
    public String supprimerCDDemande() throws Exception {
        try {
            appliService.supprimerCDDemande(idCDDemande);
            return SUCCESS;
        } catch (Exception e) {
            return ERROR;
        }
    }

    /**
     * Ajouter une CD Etape
     * 
     * @return String
     */
    public String ajouterCDEtape() throws Exception {
        try {
            if (CDEtape.equals("")) {
                erreur = getText("Admin.error.action.CDetape");
                if (descriptionCDEtape.equals("")) {
                    erreur2 = getText("Admin.error.action.descriptionCDetape");
                }
                return SUCCESS;
            }
            idCDEtape = appliService.ajouterCDEtape(idCDDemande, CDEtape, descriptionCDEtape);
            return SUCCESS;
        } catch (RuntimeException re) {
            return ERROR;
        }
    }

    /**
     * Ajouter une CD Etape sélectionnée
     * 
     * @return String
     */
    public String ajouterSelectionCDEtape() throws Exception {
        CDEtape = appliService.ajouterSelectionCDEtape(idCDDemande, idCDEtape);
        return SUCCESS;
    }

    /**
     * Récupérer les étapes CD
     * 
     * @return
     */
    public String recupererCDEtapes() throws Exception {
        for (CDEtapeEntity e : appliService.recupererCDEtapes(idCDDemande)) {
            mapCDEtapes.put(String.valueOf(e.getIdentifiantCDEtape()), e.getNomCDEtape());
        }
        return SUCCESS;
    }

    /**
     * Récupérer toutes les étapes CD
     * 
     * @return
     */
    public String recupererToutesCDEtapes() throws Exception {
        for (CDEtapeEntity e : appliService.recupererToutesCDEtapes(idCDDemande)) {
            mapCDEtapes.put(String.valueOf(e.getIdentifiantCDEtape()), e.getNomCDEtape());
        }
        return SUCCESS;
    }

    /**
     * Récupérer la description de l'étape CD
     * 
     * @return
     */
    public String recupererDescriptionCDEtape() throws Exception {
        descriptionCDEtape = appliService.recupererDescriptionCDEtape(idCDEtape);
        return SUCCESS;
    }

    /**
     * Modifier la description de CDEtape
     * 
     * @return
     * @throws Exception
     */
    public String modifierDescriptionCDEtape() throws Exception {
        if (descriptionCDEtape.equals("")) {
            erreur = getText("Admin.error.action.modifdescriptionCDetape");
            return SUCCESS;
        }
        appliService.modifierDescriptionEtape(idCDEtape, descriptionCDEtape);
        return SUCCESS;
    }

    /**
     * Supprimer une étape CD
     * 
     * @return
     * @throws Exception
     */
    public String supprimerCDEtape() throws Exception {
        try {
            appliService.supprimerCDEtape(idCDEtape, idCDDemande);
            return SUCCESS;
        } catch (Exception e) {
            return ERROR;
        }
    }

    /**
     * Supprimer définitivement une étape CD
     * 
     * @return
     * @throws Exception
     */
    public String supprimerDefinitivementCDEtape() throws Exception {
        try {
            appliService.supprimerDefinitivementCDEtape(idCDEtape);
            return SUCCESS;
        } catch (Exception e) {
            return ERROR;
        }
    }

    /** CDPointDeControle **/

    /**
     * Ajouter un nouveau cd point de contrôle
     * 
     * @return
     * @throws Exception
     */
    public String ajouterCDPointControle() throws Exception {
        try {
            if (CDPointControle.equals("") || typeSaisieCDPointControle == null) {
                if (CDPointControle.equals("")) {
                    erreur = getText("Admin.error.action.CDpointcontrole");
                }
                if (typeSaisieCDPointControle == null) {
                    erreur2 = getText("Admin.error.action.typesaisieCDpointcontrole");
                }
                return SUCCESS;
            } else {
                idCDPointControle = appliService.ajouterCDPointControle(idCDDemande, CDPointControle, typeSaisieCDPointControle);
                return SUCCESS;
            }
        } catch (RuntimeException re) {
            return ERROR;
        }
    }

    /**
     * Ajouter un point de contrôle existant
     * 
     * @return
     * @throws Exception
     */
    public String ajouterSelectionCDPointControle() throws Exception {
        CDPointControle = appliService.ajouterSelectionCDPointControle(idCDDemande, idCDPointControle);
        return SUCCESS;
    }

    /**
     * Récupérer les CDPoints de contrôle d'une CDdemande
     * 
     * @return
     * @throws Exception
     */
    public String recupererCDPointsControle() throws Exception {
        for (CDPointDeControleEntity pc : appliService.recupererCDPointsControle(idCDDemande)) {
            listeIdCDPointsControle.add(String.valueOf(pc.getIdentifiantCDPointDeControle()));
            listeNomsCDPointsControle.add(pc.getNomCDPointDeControle());
        }
        return SUCCESS;
    }

    /**
     * Récupérer les CDPoints de contrôle qui ne sont pas dans la CDdemande
     * 
     * @return
     * @throws Exception
     */
    public String recupererTousCDPointsControle() throws Exception {
        for (CDPointDeControleEntity pc : appliService.recupererTousCDPointsControle(idCDDemande)) {
            mapCDPointsControle.put(String.valueOf(pc.getIdentifiantCDPointDeControle()), pc.getNomCDPointDeControle());

        }
        return SUCCESS;
    }

    /**
     * Récupérer le numéro d'un cd point de contrôle
     * 
     * @return
     * @throws Exception
     */
    public String recupererNumeroCDPointControle() throws Exception {
        try {
            numeroCDPointControle = appliService.recupererNumeroCDPointControle(idCDPointControle, idCDDemande);
            return SUCCESS;
        } catch (Exception e) {
            return ERROR;
        }
    }

    /**
     * Modifier le numéro du CDPointDeControle pour une demande
     * 
     * @return
     * @throws Exception
     */
    public String modifierNumeroCDPointControle() throws Exception {
        try {
            if (numeroEnvoyeCDPointControle.equals("")) {
                erreur = getText("Admin.paramdemandes.erreur.numerovideCDpointcontrole");
                return SUCCESS;
            } else {
                numeroCDPointControle = Integer.valueOf(numeroEnvoyeCDPointControle);
                if (!appliService.testerNumeroCDPointControle(idCDDemande, numeroCDPointControle)) {
                    erreur = getText("Admin.paramdemandes.erreur.numerograndCDpointcontrole");
                    return SUCCESS;
                } else if (numeroCDPointControle == 0) {
                    erreur = getText("Admin.paramdemandes.erreur.numero0CDpointcontrole");
                    return SUCCESS;
                }
                appliService.modifierNumeroCDPointControle(idCDPointControle, idCDDemande, numeroCDPointControle);
                return SUCCESS;
            }
        } catch (Exception e) {
            return ERROR;
        }
    }

    /**
     * Supprimer le CDPoint de contrôle dans une CDdemande
     * 
     * @return
     * @throws Exception
     */
    public String supprimerCDPointControle() throws Exception {
        try {
            appliService.supprimerCDPointControle(idCDPointControle, idCDDemande);
            return SUCCESS;
        } catch (Exception e) {
            return ERROR;
        }
    }

    /**
     * Supprimer définitivement le CDPoint de contrôle
     * 
     * @return
     * @throws Exception
     */
    public String supprimerDefinitivementCDPointControle() throws Exception {
        try {
            appliService.supprimerDefinitivementCDPointControle(idCDPointControle);
            return SUCCESS;
        } catch (Exception e) {
            return ERROR;
        }
    }

    /** CDParametreDemande **/

    /**
     * Ajouter un CDParametreDemande
     * 
     * @return
     * @throws Exception
     */
    public String ajouterCDParametreDemande() throws Exception {
        try {
            boolean obligation;
            if (CDParametreDemande.equals("") || typeSaisieCDParametreDemande.equals(String.valueOf(-1))) {
                if (CDParametreDemande.equals("")) {
                    erreur = getText("Admin.error.action.CDparametredemande");
                }
                if (typeSaisieCDParametreDemande.equals(String.valueOf(-1))) {
                    erreur2 = getText("Admin.error.action.typesaisieCDparametredemande");
                }
                if (descriptionCDParametreDemande.equals("")) {
                    erreur3 = getText("Admin.error.action.descriptionCDparametredemande");
                }
                return SUCCESS;
            } else {
                if (obligatoireCDParametreDemande.equals("Obligatoire")) {
                    obligation = true;
                } else {
                    obligation = false;
                }
                if (typeSaisieCDParametreDemande.equals("Numérique")) {
                    typeSaisieCDParametreDemande = "num";
                } else if (typeSaisieCDParametreDemande.equals("Texte libre")) {
                    typeSaisieCDParametreDemande = "input";
                } else if (typeSaisieCDParametreDemande.equals("Liste")) {
                    typeSaisieCDParametreDemande = "liste";
                } else if (typeSaisieCDParametreDemande.equals("Liste à sélection simple")) {
                    typeSaisieCDParametreDemande = "select";
                } else if (typeSaisieCDParametreDemande.equals("Liste à sélection multiple")) {
                    typeSaisieCDParametreDemande = "selectmultiple";
                } else if (typeSaisieCDParametreDemande.equals("Date")) {
                    typeSaisieCDParametreDemande = "date";
                } else {
                    typeSaisieCDParametreDemande = "fichier";
                }
                idCDParametreDemande =
                        appliService.ajouterCDParametreDemande(idCDDemande, CDParametreDemande, obligation, typeSaisieCDParametreDemande,
                                descriptionCDParametreDemande, valeursCDParametreDemande);
                return SUCCESS;
            }
        } catch (RuntimeException re) {
            return ERROR;
        }
    }

    /**
     * Ajouter un CDParametreDemande n'existant pas dans la CDDemande
     * 
     * @return
     * @throws Exception
     */
    public String ajouterSelectionCDParametreDemande() throws Exception {
        try {
            boolean obligation;
            if (obligatoireCDParametreDemande.equals("Obligatoire")) {
                obligation = true;
            } else {
                obligation = false;
            }
            CDParametreDemande = appliService.ajouterSelectionCDParametreDemande(idCDDemande, idCDParametreDemande, obligation, descriptionCDParametreDemande);
            return SUCCESS;
        } catch (RuntimeException re) {
            return ERROR;
        }
    }

    /**
     * Récupérer les CDParametresDemande d'une CDDemande
     * 
     * @return
     * @throws Exception
     */
    public String recupererCDParametresDemande() throws Exception {
        for (CDParametreDemandeEntity pd : appliService.recupererCDParametresDemande(idCDDemande)) {
            mapCDParametresDemande.put(String.valueOf(pd.getIdentifiantParametreDemande()), pd.getNomParametreDemande());
        }
        return SUCCESS;
    }

    /**
     * Récupérer les CDParametresDemande qui ne sont pas dans la CDdemande
     * 
     * @return
     * @throws Exception
     */
    public String recupererTousCDParametresDemande() throws Exception {
        for (CDParametreDemandeEntity pd : appliService.recupererTousCDParametresDemande(idCDDemande)) {
            mapCDParametresDemande.put(String.valueOf(pd.getIdentifiantParametreDemande()), pd.getNomParametreDemande());
        }
        return SUCCESS;
    }

    /**
     * Récupérer la description de CDParametreDemande
     * 
     * @return
     */
    public String recupererDescriptionCDParametreDemande() throws Exception {
        descriptionCDParametreDemande = appliService.recupererDescriptionCDParametreDemande(idCDDemande, idCDParametreDemande);
        return SUCCESS;
    }

    /**
     * Récupérer le Type de saisie de CDParametreDemande
     * 
     * @return
     */
    public String recupererTypeSaisieCDParametreDemande() throws Exception {
        typeSaisieCDParametreDemande = appliService.recupererTypeSaisieCDParametreMaDemande(idCDParametreDemande);
        return SUCCESS;
    }

    /**
     * Modifier la description de CDParametreDemande
     * 
     * @return
     * @throws Exception
     */
    public String modifierDescriptionCDParametreDemande() throws Exception {
        if (descriptionCDParametreDemande.equals("")) {
            erreur = getText("Admin.error.action.modifdescriptionCDparametredemande");
            return SUCCESS;
        }
        appliService.modifierDescriptionCDParametreDemande(idCDDemande, idCDParametreDemande, descriptionCDParametreDemande);
        return SUCCESS;
    }

    /**
     * Supprimer le CDParametreDemande dans une CDdemande
     * 
     * @return
     * @throws Exception
     */
    public String supprimerCDParametreDemande() throws Exception {
        try {
            appliService.supprimerCDParametreDemande(idCDParametreDemande, idCDDemande);
            return SUCCESS;
        } catch (Exception e) {
            return ERROR;
        }
    }

    /**
     * Supprimer définitivement le CDParametreDemande
     * 
     * @return
     * @throws Exception
     */
    public String supprimerDefinitivementCDParametreDemande() throws Exception {
        try {
            appliService.supprimerDefinitivementCDParametreDemande(idCDParametreDemande);
            return SUCCESS;
        } catch (Exception e) {
            return ERROR;
        }
    }

    /** CDParametreDemande **/

    /**
     * Ajouter un CDParametreDemandeValeurs
     * 
     * @return
     * @throws Exception
     */
    public String ajouterCDParametreDemandeValeurs() throws Exception {
        try {
            if (CDParametreDemandeValeurs.equals("")) {
                erreur = getText("Admin.error.action.CDparametredemandevaleurs");
                return SUCCESS;
            } else {
                idCDParametreDemandeValeurs = appliService.ajouterCDParametreDemandeValeurs(idCDParametreDemande, CDParametreDemandeValeurs);
                return SUCCESS;
            }
        } catch (RuntimeException re) {
            return ERROR;
        }
    }

    /**
     * Récupérer les CDParametresDemandeValeurs d'un CDParametreDemande
     * 
     * @return
     * @throws Exception
     */
    public String recupererCDParametresDemandeValeurs() throws Exception {
        for (CDParametreDemandeValeursEntity pdv : appliService.recupererCDParametresDemandeValeurs(idCDParametreDemande)) {
            mapCDParametresDemandeValeurs.put(String.valueOf(pdv.getIdentifiantCDParametreDemandeValeurs()), pdv.getValeurCDParametreDemandeValeurs());
        }
        return SUCCESS;
    }

    /**
     * Supprimer le CDParametreDemandeValeurs
     * 
     * @return
     * @throws Exception
     */
    public String supprimerCDParametreDemandeValeurs() throws Exception {
        try {
            appliService.supprimerCDParametreDemandeValeurs(idCDParametreDemandeValeurs);
            return SUCCESS;
        } catch (Exception e) {
            return ERROR;
        }
    }

    /**
     * CDParametreEtape
     * 
     * /** Ajouter un ParametreEtapeCD
     * 
     * @return String
     */
    public String ajouterCDParametreEtape() throws Exception {
        try {
            if (CDParametreEtape.equals("") || typeSaisieCDParametreEtape == null
                    || (valeurFixeCDParametreEtape.equals("") && typeSaisieCDParametreEtape.equals("Administrateur"))) {
                if (CDParametreEtape.equals("")) {
                    erreur = getText("Admin.error.action.CDparametreetape");
                }
                if (descriptionCDParametreEtape.equals("")) {
                    erreur2 = getText("Admin.error.action.descriptionCDparametreetape");
                }
                if (typeSaisieCDParametreEtape == null) {
                    erreur3 = getText("Admin.error.action.typeSaisieCDparametreetape");
                } else if (valeurFixeCDParametreEtape.equals("") && typeSaisieCDParametreEtape.equals("Administrateur")) {
                    erreur4 = getText("Admin.error.action.valeurFixeCDParametreEtape");
                }
                return SUCCESS;
            }
            idCDParametreEtape =
                    appliService.ajouterCDParametreEtape(idCDEtape, CDParametreEtape, typeSaisieCDParametreEtape, descriptionCDParametreEtape,
                            valeurFixeCDParametreEtape);
            return SUCCESS;
        } catch (RuntimeException re) {
            return ERROR;
        }
    }

    /**
     * Ajouter un CDParametreEtape sélectionné
     * 
     * @return String
     */
    public String ajouterSelectionCDParametreEtape() throws Exception {
        if (appliService.testerTypeSaisieCDParametreEtape(idCDParametreEtape).equals("admin")) {
            if (valeurFixeCDParametreEtape.equals("")) {
                erreur = getText("Admin.error.action.valeurFixeCDParametreEtape");
                return SUCCESS;
            }
        }
        CDParametreEtape = appliService.ajouterSelectionCDParametreEtape(idCDEtape, idCDParametreEtape, valeurFixeCDParametreEtape);
        return SUCCESS;
    }

    /**
     * Fonction qui permet de tester le type de saisie de l
     * 
     * @return
     */
    public String testerTypeSaisieCDParametreEtape() throws Exception {
        typeSaisieCDParametreEtape = appliService.testerTypeSaisieCDParametreEtape(idCDParametreEtape);
        return SUCCESS;
    }

    /**
     * Récupérer les CDParametresEtape
     * 
     * @return
     */
    public String recupererCDParametresEtape() throws Exception {
        for (CDParametreEtapeEntity pe : appliService.recupererCDParametresEtape(idCDEtape)) {
            mapCDParametresEtape.put(String.valueOf(pe.getIdentifiantCDParametreEtape()), pe.getNomCDParametreEtape());
        }
        return SUCCESS;
    }

    /**
     * Fonction qui permet de récupérer les informations sur un CD Paramètre Etape
     * 
     * @return
     * @throws Exception
     */
    public String recupererCDParametreEtape() throws Exception {
        CDParametreEtapeEntity pe = new CDParametreEtapeEntity();
        pe = appliService.recupererCDParametreEtape(idCDParametreEtape);
        descriptionCDParametreEtape = pe.getDescriptionCDParametreEtape();
        typeSaisieCDParametreEtape = pe.getTypeSaisieCDParametreEtape();
        valeurFixeCDParametreEtape = appliService.recupererValeurCDParametreEtape(idCDEtape, idCDParametreEtape);
        return SUCCESS;
    }

    /**
     * Récupérer tous les CDParametresEtape
     * 
     * @return
     */
    public String recupererTousCDParametresEtape() throws Exception {
        for (CDParametreEtapeEntity pe : appliService.recupererTousCDParametresEtape(idCDEtape)) {
            mapCDParametresEtape.put(String.valueOf(pe.getIdentifiantCDParametreEtape()), pe.getNomCDParametreEtape());
        }
        return SUCCESS;
    }

    /**
     * Modifier la description de CDParametreEtape
     * 
     * @return
     * @throws Exception
     */
    public String modifierCDParametreEtape() throws Exception {
        if (valeurFixeCDParametreEtape.equals("")) {
            if (descriptionCDParametreEtape.equals("")) {
                erreur = getText("Admin.error.action.modifdescriptionCDparametreetape");
            }
            if (valeurFixeCDParametreEtape.equals("")) {
                erreur2 = getText("Admin.error.action.modifValeurFixeCDparametreetape");
            }
            return SUCCESS;
        }
        if (valeurFixeCDParametreEtape.equals("null")) {
            valeurFixeCDParametreEtape = null;
        }
        appliService.modifierCDParametreEtape(idCDEtape, idCDParametreEtape, descriptionCDParametreEtape, valeurFixeCDParametreEtape);
        return SUCCESS;
    }

    /**
     * Supprimer un CDParametreEtape d'une CDEtape
     * 
     * @return
     * @throws Exception
     */
    public String supprimerCDParametreEtape() throws Exception {
        try {
            appliService.supprimerCDParametreEtape(idCDParametreEtape, idCDEtape);
            return SUCCESS;
        } catch (Exception e) {
            return ERROR;
        }
    }

    /**
     * Supprimer définitivement un CDParametreEtape
     * 
     * @return
     * @throws Exception
     */
    public String supprimerDefinitivementCDParametreEtape() throws Exception {
        try {
            appliService.supprimerDefinitivementCDParametreEtape(idCDParametreEtape);
            return SUCCESS;
        } catch (Exception e) {
            return ERROR;
        }
    }

    /** CPParametreEtape **/

    /**
     * Ajouter un CPParametreEtape
     * 
     * @return
     * @throws Exception
     */
    public String ajouterCPParametreEtape() throws Exception {
        try {
            if (CPParametreEtape.equals("")) {
                erreur = getText("Admin.error.action.CPParametreEtape");
                return SUCCESS;
            } else {
                idCPParametreEtape = appliService.ajouterCPParametreEtape(idCDParametreEtape, CPParametreEtape);
                return SUCCESS;
            }
        } catch (RuntimeException re) {
            return ERROR;
        }
    }

    /**
     * Récupérer les CPParametresEtape d'un CDParametreEtape
     * 
     * @return
     * @throws Exception
     */
    public String recupererCPParametresEtape() throws Exception {
        for (CPParametreEtapeEntity cppe : appliService.recupererCPParametresEtape(idCDParametreEtape)) {
            mapCPParametresEtape.put(String.valueOf(cppe.getIdentifiantCPParametreEtape()), cppe.getValeurCPParametreEtape());
        }
        return SUCCESS;
    }

    /**
     * Supprimer le CPParametresEtape
     * 
     * @return
     * @throws Exception
     */
    public String supprimerCPParametreEtape() throws Exception {
        try {
            appliService.supprimerCPParametreEtape(idCPParametreEtape);
            return SUCCESS;
        } catch (Exception e) {
            return ERROR;
        }
    }

    /**
     * Correspondance Paramètres
     * 
     * /** Fonction pour ajouter une correspondance entre deux paramètres
     * 
     * @param idCorrespondanceParametresDemande
     * @param idCorrespondanceParametresEtape
     * @return
     * @throws Exception
     */
    public String ajouterCorrespondanceParametres() throws Exception {
        try {
            if (corpardem.equals("") || corparet.equals("")) {
                if (corpardem.equals("")) {
                    erreur = getText("Admin.error.action.paramdemandecorrespondanceparametres");
                }
                if (corparet.equals("")) {
                    erreur2 = getText("Admin.error.action.parametapecorrespondanceparametres");
                }
                return SUCCESS;
            } else {
                idCorrespondanceParametresDemande = Integer.valueOf(corpardem);
                idCorrespondanceParametresEtape = Integer.valueOf(corparet);
                idCorrespondanceParametres = appliService.ajouterCorrespondanceParametres(idCorrespondanceParametresDemande, idCorrespondanceParametresEtape);
                return SUCCESS;
            }
        } catch (RuntimeException re) {
            return ERROR;
        }
    }

    /**
     * Récupérer les correspondances paramètres
     * 
     * @return
     * @throws Exception
     */
    public String recupererCorrespondancesParametres() throws Exception {
        for (CorrespondanceParametresEntity cp : appliService.recupererCorrespondancesParametres(idCDDemande, idCDEtape)) {
            CDParametreDemande = cp.getCDParametresDemandeCorrespondanceParametre().getNomParametreDemande();
            CDParametreEtape = cp.getCDParametresEtapeCorrespondanceParametre().getNomCDParametreEtape();
            mapCorrespondancesParametres.put(String.valueOf(cp.getIdentifiantCorrespondanceParametres()), CDParametreDemande + " - " + CDParametreEtape);
        }
        return SUCCESS;
    }

    /**
     * Récupérer les paramètres de demande pouvant être associés dans une correspondance
     * 
     * @return
     * @throws Exception
     */
    public String recupererToutesCorrespondancesParametresDemande() throws Exception {
        for (CDParametreDemandeEntity pd : appliService.recupererCorrespondancesParametresDemande(idCDDemande)) {
            mapCorrespondancesParametresDemande.put(String.valueOf(pd.getIdentifiantParametreDemande()), pd.getNomParametreDemande());
        }
        return SUCCESS;
    }

    /**
     * Récupérer les paramètres d'étape pouvant être associés dans une correspondance
     * 
     * @return
     * @throws Exception
     */
    public String recupererToutesCorrespondancesParametresEtape() throws Exception {
        for (CDParametreEtapeEntity pe : appliService.recupererCorrespondancesParametresEtape(idCDEtape)) {
            mapCorrespondancesParametresEtape.put(String.valueOf(pe.getIdentifiantCDParametreEtape()), pe.getNomCDParametreEtape());
        }
        return SUCCESS;
    }

    /**
     * Supprimer une correspondance paramètres
     * 
     * @return
     * @throws Exception
     */
    public String supprimerCorrespondanceParametres() throws Exception {
        try {
            appliService.supprimerCorrespondanceParametres(idCorrespondanceParametres);
            return SUCCESS;
        } catch (Exception e) {
            return ERROR;
        }
    }

    /**
     * Accesseur de valeursCDParametreDemande
     * 
     * @return le valeursCDParametreDemande
     */
    public String getValeursCDParametreDemande() {
        return valeursCDParametreDemande;
    }

    /**
     * Affectation de valeursCDParametreDemande
     * 
     * @param valeursCDParametreDemande valeursCDParametreDemande à affecter
     */
    public void setValeursCDParametreDemande(String valeursCDParametreDemande) {
        this.valeursCDParametreDemande = valeursCDParametreDemande;
    }

}
